home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / XINE-1.ZIP / INJECTOR.ZIP / SRC / MAIN.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-10-25  |  7.3 KB  |  408 lines
  1.  
  2. /* MUST be compiled in medium memory model cause the function call in
  3.    receiver routine must have CS declared explicitly ! */
  4.  
  5.  
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <conio.h>
  9. #include <alloc.h>
  10. #include <dos.h>
  11. #include <ctype.h>
  12. #include <string.h>
  13.  
  14.  
  15. #include "pktdrvr.h"
  16. #include "netool.h"
  17. #include "parse.h"
  18.  
  19.  
  20. int intno=96;
  21. int ifclass=11;
  22. int iftype=0xffff;
  23. int ifno=0;
  24. int ver=-1;
  25. int rhandle;
  26. int fun=-1;
  27. int pl=0;
  28.  
  29.  
  30. int winh, maxh, xu, yu, xd, yd;
  31. int far save_ds;
  32. int buffer_ready=1;
  33. unsigned char buffer[4000];
  34. struct netpacket pkt;
  35. int llen;
  36. unsigned char volatile myetheraddr[6];  /* from ethernet adress */
  37. unsigned char volatile toetheraddr[6];    /* to ethernet adress */
  38. unsigned char myipaddr[4];        /* from IP adress */
  39. unsigned char toipaddr[4];        /* to IP adress */
  40.  
  41. FILE * f;
  42.  
  43. unsigned char tb[4000];
  44. unsigned char *tp;
  45. unsigned char tparp[200];
  46.  
  47. int volatile ishooked=0;
  48. void (*hookfun) (char *, int, struct netpacket *);
  49.  
  50.  
  51. char maskipsrc[4]={0,0,0,0};
  52. char maskipdst[4]={0,0,0,0};
  53. int maskpsrc=0;
  54. int maskpdst=0;
  55. int noother=0;
  56. int masktype=0;
  57.  
  58. void receiver ()
  59. {
  60.  
  61.     int flag=_AX;
  62. /*    int handle=_BX; */
  63.     int len=_CX;
  64.  
  65.     int i;
  66.  
  67.     asm pop dx;         /* nasty hack for TC code generation */
  68.     asm pop dx;        /* that idiot always saves di and si */
  69.  
  70.     _DS=save_ds;
  71.  
  72.     if (flag)
  73.     {
  74.                 /* setup screen */
  75.         xd=wherex();
  76.         yd=wherey();
  77.         window(1,1,80,winh);
  78.         gotoxy(xu,yu);
  79.  
  80.                 /* here the packet in buffer is analyzed */
  81.  
  82.         analyze(buffer,&pkt);
  83.         if (ishooked) (*hookfun)(buffer,llen,&pkt);
  84.         if (pkt.type==UNKNOWN && !noother)
  85.         {       tp="ETH: from: ";
  86.             cputs(tp);
  87.             if (logging)
  88.                 fputs(tp,f);
  89.             sprintf(tb,"%2X",pkt.ethfrom[0]);
  90.             cputs(tb);
  91.             if (logging)
  92.                 fputs(tb,f);
  93.             for (i=1;i<6;i++)
  94.             {
  95.                 sprintf(tb,":%2X",pkt.ethfrom[i]);
  96.                 cputs(tb);
  97.                 if (logging)
  98.                     fputs(tb,f);
  99.             }
  100.             tp=" to: ";
  101.             cputs(tp);
  102.             if (logging)
  103.                 fputs(tp,f);
  104.             sprintf(tb,"%2X",pkt.ethto[0]);
  105.             cputs(tb);
  106.             if (logging)
  107.                 fputs(tb,f);
  108.             for (i=1;i<6;i++)
  109.             {
  110.                 sprintf(tb,":%2X",pkt.ethto[i]);
  111.             cputs(tb);
  112.             if (logging)
  113.                 fputs(tb,f);
  114.             }
  115.             tp=" NOT TCP/IP\n\n";
  116.             cprintf("%s\r",tp);
  117.             if (logging)
  118.                 fputs(tp,f);
  119.         }
  120.         if ((
  121.              ( !maskipsrc[0] || (maskipsrc[0]==pkt.ipfrom[0]) ) &&
  122.              ( !maskipsrc[1] || (maskipsrc[1]==pkt.ipfrom[1]) ) &&
  123.              ( !maskipsrc[2] || (maskipsrc[2]==pkt.ipfrom[2]) ) &&
  124.              ( !maskipsrc[3] || (maskipsrc[3]==pkt.ipfrom[3]) ) &&
  125.              ( !maskipdst[0] || (maskipdst[0]==pkt.ipto[0]) ) &&
  126.              ( !maskipdst[1] || (maskipdst[1]==pkt.ipto[1]) ) &&
  127.              ( !maskipdst[2] || (maskipdst[2]==pkt.ipto[2]) ) &&
  128.              ( !maskipdst[3] || (maskipdst[3]==pkt.ipto[3]) ) &&
  129.              ( !maskpdst || (maskpdst==pkt.portto) ) &&
  130.              ( !maskpsrc || (maskpsrc==pkt.portfrom) ) &&
  131.              ( !masktype || (masktype==pkt.type) )
  132.            ) && (pkt.type!=ARP) )
  133.  
  134.         {
  135.             switch (pkt.type)
  136.             {
  137.                 case TCPIP:     tp="TCPIP: ";     break;
  138.                 case UDPIP:     tp="UDPIP: ";     break;
  139.                 case ICMP:    tp="ICMP: ";    break;
  140.                 case IPUNKNOWN: tp="?IP: ";    break;
  141.             }
  142.             cputs(tp);
  143.             if (logging)
  144.                 fputs(tp,f);
  145.             sprintf(tb,"%hu",pkt.ipfrom[0]);
  146.             cputs(tb);
  147.             if (logging)
  148.                 fputs(tb,f);
  149.  
  150.             for (i=1;i<4;i++)
  151.             {
  152.                 sprintf(tb,".%hu",pkt.ipfrom[i]);
  153.                 cputs(tb);
  154.                 if (logging)
  155.                     fputs(tb,f);
  156.             }
  157.             if (pkt.type==TCPIP || pkt.type==UDPIP)
  158.             {
  159.                 sprintf(tb,":%u",pkt.portfrom);
  160.                 cputs(tb);
  161.                 if (logging)
  162.                     fputs(tb,f);
  163.             }
  164.             tp=" to ";
  165.             cputs(tp);
  166.             if (logging)
  167.                 fputs(tp,f);
  168.             sprintf(tb,"%hu",pkt.ipto[0]);
  169.             cputs(tb);
  170.             if (logging)
  171.                 fputs(tb,f);
  172.             for (i=1;i<4;i++)
  173.             {
  174.                 sprintf(tb,".%hu",pkt.ipto[i]);
  175.                 cputs(tb);
  176.                 if (logging)
  177.                     fputs(tb,f);
  178.             }
  179.             if (pkt.type==TCPIP || pkt.type==UDPIP)
  180.             {
  181.                 sprintf(tb,":%u",pkt.portto);
  182.                 cputs(tb);
  183.                 if (logging)
  184.                     fputs(tb,f);
  185.             }
  186.             if (pkt.isfrag)
  187.             {
  188.                 tp=" FR";
  189.                 cputs(tp);
  190.                 if (logging)
  191.                     fputs(tp,f);
  192.  
  193.             }
  194.  
  195.             if (pkt.issyn && pkt.type==TCPIP)
  196.             {
  197.                 tp=" SYN";
  198.                 cputs(tp);
  199.                 if (logging)
  200.                     fputs(tp,f);
  201.  
  202.             }
  203.             if (pkt.isack && pkt.type==TCPIP)
  204.             {
  205.                 tp=" ACK";
  206.                 cputs(tp);
  207.                 if (logging)
  208.                     fputs(tp,f);
  209.  
  210.             }
  211.             if (pkt.isfin&& pkt.type==TCPIP)
  212.             {
  213.                 tp=" FIN";
  214.                 cputs(tp);
  215.                 if (logging)
  216.                     fputs(tp,f);
  217.  
  218.             }
  219.  
  220.             tp="\n";
  221.             cprintf("%s\r",tp);
  222.             if (logging)
  223.                 fputs(tp,f);
  224.             cputs(pkt.textdata);
  225.             if (logging)
  226.                 fputs(pkt.textdata,f);
  227.             tp="\n\n";
  228.             cprintf("%s\r",tp);
  229.             if (logging)
  230.                 fputs(tp,f);
  231.  
  232.         }
  233.  
  234.         if (pkt.type==ARP)
  235.         {
  236.             strcpy (tparp,"ARP: ");
  237.             if (pkt.proto==1)
  238.                 strcat(tparp,"request for ");
  239.             else
  240.                 strcat(tparp,"answer for ");
  241.             sprintf(tb,"%hu",pkt.ipto[0]);
  242.             strcat(tparp,tb);
  243.             for (i=1;i<4;i++)
  244.             {
  245.                 sprintf(tb,".%hu",pkt.ipto[i]);
  246.                 strcat(tparp,tb);
  247.             }
  248.             if (pkt.proto==1)
  249.                 sprintf(tb," HW FROM: 0");
  250.             else
  251.                 sprintf(tb," IS: 0");
  252.             strcat(tparp,tb);
  253.             for (i=1;i<6;i++)
  254.             {
  255.                 sprintf(tb,":%2X",pkt.etharp[i]);
  256.                 strcat(tparp,tb);
  257.             }
  258.  
  259.             strcat(tparp,"\n\r");
  260.             cputs(tparp);
  261.             if (logging)
  262.                 fputs(tparp,f);
  263.  
  264.         }
  265.                 /* restore screen */
  266.         xu=wherex();
  267.         yu=wherey();
  268.         window(1,winh+1,80,maxh);
  269.         gotoxy(xd,yd);
  270.  
  271.         buffer_ready=1;
  272.  
  273.     }
  274.     else
  275.     {
  276.         if (buffer_ready)
  277.         {
  278.             buffer_ready=0;
  279.             llen=len;
  280.             _ES=FP_SEG(buffer);
  281.             _DI=FP_OFF(buffer);
  282.         }
  283.         else
  284.         {
  285.             pl=1;
  286.             _ES=0;
  287.             _SI=0;
  288.         }
  289.     }
  290.  
  291.     asm push si;        /* nasty hack as above */
  292.     asm push di;
  293.  
  294.     return;
  295. }
  296.  
  297.  
  298. void reset_card(void)
  299. {
  300.     release_type(intno,rhandle);
  301. }
  302.  
  303.  
  304. void setup_card(void)
  305. {
  306.     int err,i;
  307.  
  308.     cprintf("Injector version 0.666BETA\n\r");
  309.  
  310.     if (!test_for_pd(intno))
  311.     {
  312.         cprintf ("\nNo packet driver on int. %d\r\n",intno);
  313.         exit(1);
  314.     }
  315.  
  316.  
  317.     driver_info(intno,0,&ver,&ifclass,&iftype,&ifno,&fun);
  318.     cprintf("PD Info: ver: %d, class: %d, type: %d, no: %d, fun: %d\n\r",
  319.         ver,ifclass,iftype,ifno,fun);
  320.  
  321.     if (!(rhandle=access_type(intno,ifclass,iftype,ifno, NULL,0)))
  322.     {
  323.         cprintf ("\nCannot get needed class %d pd access\n\r", ifclass);
  324.         exit(1);
  325.     }
  326.  
  327.     atexit(reset_card);
  328.  
  329.  
  330.     if (!(set_mode (intno,rhandle,6)))
  331.     {
  332.         cprintf("\nCannot put pd in promiscuous mode\n\r");
  333.         exit(1);
  334.     }
  335.  
  336.     err=get_address(intno,rhandle,myetheraddr,6);
  337.     if (err)
  338.     {
  339.         cprintf("\nCannot get my ethernet address! error:%i\n\r",err);
  340.         exit(1);
  341.     }
  342.     else
  343.     {
  344.         cprintf("My ethernet address is: %2X",myetheraddr[0]);
  345.         for (i=1;i<6;i++)
  346.         {
  347.             cprintf(":%2X",myetheraddr[i]);
  348.         }
  349.         cprintf("\n\r");
  350.     }
  351. }
  352.  
  353. void main (void)
  354. {
  355.  
  356.     struct text_info ti;
  357.     unsigned char cl[100], *c=cl, ch; /* no unsigned */
  358.  
  359.     save_ds=_DS;
  360.     initparser();
  361.     textmode(C4350);
  362.     gettextinfo(&ti);
  363.     maxh=ti.screenheight;
  364.     winh=maxh-10;
  365.     clrscr();
  366.     window(1,winh+1,80,maxh);
  367.     setup_card();
  368.     f=fopen("injector.log","a");
  369.  
  370.     for (;;)
  371.     {
  372.         if (pl)
  373.         {
  374.             cputs("Packet Lost!\n\r");
  375.             pl=0;
  376.         }
  377.  
  378.         if (kbhit())
  379.         {
  380.             ch=getch();
  381.             if (isprint(ch))
  382.             {
  383.                 *(c++)=ch;
  384.                 putch(ch);
  385.             }
  386.             if (ch=='\b' && (c!=cl) )
  387.             {
  388.                 c--;
  389.                 gotoxy(wherex()-1,wherey());
  390.                 putch(' ');
  391.                 gotoxy(wherex()-1,wherey());
  392.             }
  393.             if (ch=='\r')
  394.             {
  395.                 *c='\0';
  396.                 cputs("\n\r");
  397.                 if (docmd(cl))
  398.                 {
  399.                     reset_card();
  400.                     fclose(f);
  401.                     exit(0);
  402.                 }
  403.                 c=cl;
  404.             }
  405.         }
  406.     }
  407.  
  408. }